home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 October: Mac OS SDK / Dev.CD Oct 96 SDK / Dev.CD Oct 96 SDK1.toast / Development Kits (Disc 1) / AppleScript / Development Tools / Sample Code / 7Edit 3.1 / Sources / SVEditAEUtils.c < prev    next >
Encoding:
Text File  |  1995-11-20  |  7.6 KB  |  338 lines  |  [TEXT/CWIE]
  1. // SVEditAEUtils.c
  2. //
  3. // 7Edit 3.1d1. Original version by Jon Lansdell and Nigel Humphreys.
  4. // 3.1 updates by Greg Sutton.
  5. // ©Apple Computer Inc 1995, all rights reserved.
  6.  
  7. #pragma segment Main
  8.  
  9. #include "SVEditAEUtils.h"
  10.  
  11. #include "SVEditUtils.h"
  12. #include "SVEditWindow.h"
  13.  
  14. #include "SVAERecording.h"
  15.  
  16. #include <AERegistry.h>
  17. #include <AEObjects.h>
  18.  
  19.  
  20. // -----------------------------------------------------------------------
  21. //    Utility Routines for getting data from AEDesc's
  22. // -----------------------------------------------------------------------
  23.     
  24. void    GetRawDataFromDescriptor(const AEDesc *theDesc,
  25.                                                                          Ptr     destPtr,
  26.                                                                          Size    destMaxSize,
  27.                                                                          Size    *actSize)
  28.   {
  29.       Size copySize;
  30.  
  31.  
  32.         if (theDesc->dataHandle) 
  33.             {
  34.                 HLock((Handle)theDesc->dataHandle);
  35.                 *actSize = GetHandleSize((Handle)theDesc->dataHandle);
  36.                 
  37.                 copySize = LesserOf(*actSize, destMaxSize);
  38.                 
  39.                 BlockMove(*theDesc->dataHandle, destPtr, copySize);
  40.                 
  41.                 HUnlock((Handle)theDesc->dataHandle);
  42.             }
  43.         else
  44.             *actSize = 0;
  45.     } /*GetRawDataFromDescriptor*/
  46.  
  47.  
  48. OSErr    GetPStringFromDescriptor(const AEDesc *aDesc, StringPtr resultStr)
  49. {
  50.     Size         stringSize;
  51.     AEDesc       resultDesc = {typeNull, NULL};
  52.     OSErr        err;
  53.     
  54.     err = AECoerceDesc(aDesc, typeChar, &resultDesc);
  55.     if (noErr != err) goto done;
  56.     
  57.     resultStr[0] = 0;
  58.     
  59.     GetRawDataFromDescriptor(&resultDesc, (Ptr)&resultStr[1], 255, &stringSize);
  60.     if (stringSize <= 255) 
  61.         resultStr[0] = stringSize;
  62.     else
  63.         err = errAECoercionFail;
  64.  
  65. done:        
  66.     if (resultDesc.dataHandle) 
  67.         AEDisposeDesc(&resultDesc);
  68.         
  69.     return(err);
  70. }
  71.     
  72.  
  73. OSErr    PutPStringToDescriptor(AEDesc* aDesc, StringPtr pStr)
  74. {
  75.     OSErr        err;
  76.     
  77.     if (! aDesc || ! pStr)
  78.         return(errAETypeError);
  79.  
  80.     err = AECreateDesc(typeChar, (Ptr)&pStr[1], pStr[0], aDesc);
  81.         
  82.     return(err);
  83. }
  84.  
  85.  
  86. OSErr    GetIntegerFromDescriptor(const AEDesc *sourceDesc, short *result)
  87.   {
  88.       OSErr   myErr;
  89.         OSErr   ignoreErr;
  90.         Size    intSize;
  91.         AEDesc  resultDesc;
  92.         
  93.         *result = 0;
  94.         myErr  = AECoerceDesc(sourceDesc,typeShortInteger,&resultDesc);
  95.         
  96.         if (myErr==noErr) 
  97.             {
  98.                 GetRawDataFromDescriptor(&resultDesc,
  99.                                                                  (Ptr)result,
  100.                                                                  2,
  101.                                                                  &intSize);
  102.                 if (intSize>2) 
  103.                     myErr = errAECoercionFail;
  104.             }
  105.         
  106.         if (resultDesc.dataHandle) 
  107.             ignoreErr = AEDisposeDesc(&resultDesc);
  108.             
  109.         return(myErr);
  110.     }
  111.     
  112. OSErr    GetBooleanFromDescriptor(const AEDesc *sourceDesc,
  113.                                                                         Boolean *result)
  114.   {
  115.       OSErr  myErr;
  116.         OSErr  ignoreErr;
  117.         Size   boolSize;
  118.         AEDesc resultDesc;
  119.         
  120.         *result = false;
  121.         myErr = AECoerceDesc(sourceDesc,typeBoolean,&resultDesc);
  122.         
  123.         if (myErr==noErr) 
  124.             {
  125.                 GetRawDataFromDescriptor(&resultDesc,
  126.                                                                  (Ptr)result,
  127.                                                                  sizeof(Boolean),
  128.                                                                  &boolSize);
  129.                 if (boolSize>sizeof(Boolean)) 
  130.                     myErr = errAECoercionFail;
  131.             }
  132.         
  133.         if (resultDesc.dataHandle) 
  134.             ignoreErr = AEDisposeDesc(&resultDesc);
  135.             
  136.         return(myErr);
  137.     }
  138.  
  139. OSErr    GetLongIntFromDescriptor(const AEDesc *sourceDesc, 
  140.                                       long   *result)
  141.   {
  142.       OSErr   myErr;
  143.         OSErr   ignoreErr;
  144.         Size    intSize;
  145.         AEDesc  resultDesc;
  146.         
  147.         *result = 0;
  148.         myErr = AECoerceDesc(sourceDesc,typeLongInteger,&resultDesc);
  149.         
  150.         if (myErr==noErr) 
  151.             {
  152.                 GetRawDataFromDescriptor(&resultDesc,
  153.                                                                  (Ptr)result,
  154.                                                                  4,
  155.                                                                  &intSize);
  156.                 if (intSize>4) 
  157.                     myErr = errAECoercionFail;
  158.             }
  159.         
  160.         if (resultDesc.dataHandle) 
  161.             ignoreErr = AEDisposeDesc(&resultDesc);
  162.             
  163.         return(myErr);
  164.     } /*GetLongIntFromDescriptor*/
  165.  
  166. OSErr    GetRectFromDescriptor(const AEDesc *sourceDesc, Rect *result)
  167.     {
  168.         OSErr   myErr;
  169.         OSErr   ignoreErr;
  170.         Size    rectSize;
  171.         AEDesc  resultDesc;
  172.             
  173.         SetRect(result,0,0,0,0);
  174.         myErr = AECoerceDesc(sourceDesc,typeQDRectangle,&resultDesc);
  175.         
  176.         if (myErr==noErr) 
  177.             {
  178.                 GetRawDataFromDescriptor(&resultDesc,
  179.                                                                  (Ptr)result,
  180.                                                                  sizeof(Rect),
  181.                                                                  &rectSize);
  182.                 if (rectSize<sizeof(Rect)) 
  183.                     myErr = errAECoercionFail;
  184.             }
  185.         
  186.         if (resultDesc.dataHandle) 
  187.             ignoreErr = AEDisposeDesc(&resultDesc);
  188.             
  189.         return(myErr);
  190.     } /*GetRectFromDescriptor*/
  191.  
  192. OSErr    GetPointFromDescriptor(const AEDesc *sourceDesc,
  193.                                                                   Point  *result)
  194.   {
  195.       OSErr   myErr;
  196.         OSErr   ignoreErr;
  197.         Size    ptSize;
  198.         AEDesc  resultDesc;
  199.         
  200.         SetPt(result,0,0);
  201.         
  202.         myErr = AECoerceDesc(sourceDesc,typeQDPoint,&resultDesc);
  203.         
  204.         if (myErr==noErr) 
  205.             {
  206.                 GetRawDataFromDescriptor(&resultDesc,
  207.                                                                  (Ptr)result,
  208.                                                                  sizeof(Point),
  209.                                                                  &ptSize);
  210.                                                                  
  211.                 if (ptSize<sizeof(Point)) 
  212.                     myErr = errAECoercionFail;
  213.                     
  214.             }
  215.         
  216.         if (resultDesc.dataHandle) 
  217.             ignoreErr = AEDisposeDesc(&resultDesc);
  218.             
  219.         return(myErr);
  220.     } /*GetPointFromDescriptor*/
  221.  
  222.  
  223. // ----------------------------------------------------------------------
  224. //    Name:        GotRequiredParams
  225. //    Function:    Checks all parameters defined as 'required' have been read
  226. // ----------------------------------------------------------------------
  227.                             
  228. OSErr    GotRequiredParams(const AppleEvent *theAppleEvent)
  229. {
  230.     DescType    returnedType;
  231.     Size        actualSize;
  232.     OSErr        err;
  233.     
  234.         // look for the keyMissedKeywordAttr, just to see if it's there
  235.     
  236.     err = AEGetAttributePtr(theAppleEvent, keyMissedKeywordAttr, typeWildCard,
  237.                                                 &returnedType, NULL, 0, &actualSize);
  238.     
  239.     switch (err)
  240.     {
  241.         case errAEDescNotFound:        // attribute not there means we
  242.             err = noErr;            // got all required parameters.
  243.             break;
  244.             
  245.         case noErr:                    // attribute there means missed
  246.             err = errAEParamMissed;    // at least one parameter.
  247.             break;
  248.             
  249.         // default:        pass on unexpected error in looking for the attribute
  250.     }
  251.     
  252.     return(err);
  253. } // GotReqiredParams
  254.  
  255.  
  256. // This routine takes a result descriptor, a reply descriptor and an error.
  257. // If there is a result to add to the reply it makes sure the reply isn't
  258. // NULL itself then adds the result to the reply depending on the error
  259. // and the type of result.
  260.  
  261. OSErr    AddResultToReply(AEDesc* result, AEDesc* reply, OSErr error)
  262. {
  263.     OSErr    err;
  264.  
  265.         // Check that the reply is not NULL and there is a result to put in it  
  266.     if (typeNull == reply->descriptorType || typeNull == result->descriptorType)
  267.         return(error);
  268.     
  269.     if (noErr == error)
  270.         err = AEPutParamDesc(reply, keyDirectObject, result);
  271.     else
  272.     {
  273.         switch (result->descriptorType)
  274.         {
  275.             case typeInteger:
  276.                 err = AEPutParamDesc(reply, keyErrorNumber, result);
  277.                 break;
  278.                 
  279.             case typeChar:
  280.                 err = AEPutParamDesc(reply, keyErrorString, result);
  281.                 break;
  282.                 
  283.             default:
  284.                 err = errAETypeError;
  285.         }
  286.         
  287.         if (noErr == err)
  288.             err = error;        // Don't loose that error
  289.     }
  290.  
  291.     return(err);
  292. }
  293.  
  294. // -----------------------------------------------------------------------
  295. //        Name:             MakeSelfAddress
  296. //        Purpose:        Builds an AEAddressDesc for the current process
  297. // -----------------------------------------------------------------------
  298.     
  299. OSErr    MakeSelfAddress(AEAddressDesc *selfAddress)
  300. {
  301.     ProcessSerialNumber procSerNum;
  302.     
  303.     procSerNum.highLongOfPSN = 0;
  304.     procSerNum.lowLongOfPSN  = kCurrentProcess;
  305.     
  306.     return(AECreateDesc(typeProcessSerialNumber, (Ptr)&procSerNum, sizeof(procSerNum), selfAddress));
  307. } // MakeSelfAddress
  308.  
  309.  
  310.  
  311. OSErr    GetEnumeratedFromDescriptor(const AEDesc *sourceDesc, DescType  *result)
  312. {
  313.     OSErr   myErr;
  314.     OSErr   ignoreErr;
  315.     Size    enumSize;
  316.     AEDesc  resultDesc;
  317.     
  318.     *result = typeNull;
  319.     
  320.     myErr = AECoerceDesc(sourceDesc,typeEnumerated,&resultDesc);
  321.     
  322.     if (myErr==noErr)
  323.     {
  324.         GetRawDataFromDescriptor(&resultDesc, (Ptr)result, sizeof(DescType), &enumSize);
  325.     
  326.         if (enumSize<sizeof(DescType))
  327.             myErr = errAECoercionFail;
  328.     }
  329.     
  330.     if (resultDesc.dataHandle)
  331.         ignoreErr = AEDisposeDesc(&resultDesc);
  332.     
  333.     return(myErr);
  334. } // GetEnumeratedFromDescriptor
  335.  
  336.  
  337.  
  338.